package com.crm.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.crm.entity.*;
import com.crm.service.RoleService;
import com.crm.service.UserRoleService;
import com.crm.service.UserService;
import com.crm.util.*;

import org.springframework.web.bind.annotation.RequestMapping;


import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;


@RestController//标注当前类是controller类，controller用 于处理客户端请求，加Rest表示当前类的所有方法都返回json数据，不走视图
public class UserController {
    @Resource//设置注入方式，spring 自动在spring容器找到叫这个名或这个类型的对象，赋给当前属性，controller调 用service
    private UserService userService;//user的业务层父接口
    @Resource//设置注入方式，spring 自动在spring容器找到叫这个名或这个类型的对象，赋给当前属性，controller调 用service
    private RoleService roleService;//role的业务层父接口
    @Resource//设置注入方式，spring 自动在spring容器找到叫这个名或这个类型的对象，赋给当前属性，controller调 用service
    private UserRoleService userRoleService;//userRole的业务层父接口
    private Map<String,Object> map = new HashMap<>();
    @RequestMapping("getUsersLayUI") // 客户端请求地址
    public Object getUsersLayUI(PageUtil p, User user, UserQuery userQuery) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
        Page<User> page = new Page<User>(p.getPage(), p.getLimit());//封装layui的table要 的数据格式
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();//mybatis plus条件构造器queryWrapper

        if(userQuery.getUserName()!=null && !userQuery.getUserName().isEmpty()) {//根据 Wrapper 条件，查询记录数据
            queryWrapper.like("user_name",userQuery.getUserName());
        }
        if(userQuery.getIsLockout() != null) {//根据 Wrapper 条件，查询记录数据
            queryWrapper.eq("is_lockout", userQuery.getIsLockout());
        }
        if (userQuery.getBeginTime() != null) {//根据 Wrapper 条件，查询记录数据
            queryWrapper.ge("create_time", userQuery.getBeginTime());
        }
        if (userQuery.getEndTime() != null) {//根据 Wrapper 条件，查询记录数据
            queryWrapper.le("create_time", userQuery.getEndTime());
        }

        page = userService.page(page, queryWrapper);
        return new Result(0, "", page.getRecords(), page.getTotal());//把查到的全部数据，返回给前端ajax的请求
    }

    @RequestMapping("createUser") // 客户端请求地址
    public Object createUser(User user) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        User userName = userService.getOne(new QueryWrapper<User>().eq("user_name", user.getUserName()));//使用mybatis plus条件构造器queryWrapper，根据 entity 条件，查询一条记录
        if (userName != null) {
            return new Result(1, "添加失败，该名称已存在！");//把查到的结果数据，返回给前端ajax的请求
        }
        User userPhone = userService.getOne(new QueryWrapper<User>().eq("tel", user.getTel()));//根据 entity 条件，查询一条记录
        if(userPhone !=null){
            return new Result(1,"该手机号已经注册");//把查到的结果数据，返回给前端ajax的请求
        }
        String resultString = MD5Utils.stringToMD5("123456");//调用MD5，对密码进行加密
        user.setPassword(resultString);//设置密码
        boolean i = userService.save(user);//
        if (i == true) {
            return new Result(0, "添加成功");//把查到的结果数据，返回给前端ajax的请求
        }
        return new Result(1, "添加失败");//把查到的结果数据，返回给前端ajax的请求
    }

    @RequestMapping("addUserRole") // 客户端请求地址
    public Object addUserToRole(UserRole userrole) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        boolean i = userRoleService.save(userrole);//调用mybatis plus的内 置service层方法save()，修改数据
        Map<String, Object> map = new HashMap<String, Object>();
        if (i == true) {
            map.put("code", 0);
            map.put("msg", "添加成功");//把查到的结果数据，返回给前端ajax的请求
        } else {
            map.put("code", 1);
            map.put("msg", "添加失败");
        }
        return map;
    }

    @RequestMapping("removeUserRole") // 客户端请求地址
    public Object removeUserFromRole(UserRole userrole) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        Integer i = roleService.removeUserFromRole(userrole);
        Map<String, Object> map = new HashMap<String, Object>();

        if (i > 0) {
            map.put("code", 0);
            map.put("msg", "删除成功  ");
        } else {
            map.put("code", 1);
            map.put("msg", "删除失败");
        }

        return map;
    }

    @RequestMapping("updateUser") // 客户端请求地址
    public Object updateUser(User user) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        boolean i = userService.updateById(user);//调用mybatis plus的内 置service层方法updateById()，修改数据
        if (i == true) {
            return new Result(0, "修改成功");//把查到的结果数据，返回给前端ajax的请求
        }
        return new Result(1, "修改失败");//把查到的结果数据，返回给前端ajax的请求
    }

    @RequestMapping("deleteUser") // 客户端请求地址
    public Object deleteUser(Integer uid,Token token) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        if (token != null && token.getUid().equals(uid)) {
            return new Result(1, "当前用户正在使用，不能删除");
        } else {
            List<UserRole> list = userRoleService.list(new QueryWrapper<UserRole>().eq("uid", uid));//调用mybatis plus的内 置service层方法list()，全查所有数据
            if (!list.isEmpty()) {
                return new Result(1, "该用户已有角色，删除失败！");
            }
            boolean i = userService.removeById(uid);//调用mybatis plus的内 置service层方法removeById()，删除数据
            if (i == true) {
                return new Result(0, "删除成功");//把查到的结果数据，返回给前端ajax的请求
            }
            return new Result(1, "删除失败");//把查到的结果数据，返回给前端ajax的请求
        }
    }

    @RequestMapping("updatePassWord") // 客户端请求地址
    public Object updatePassWord(String userName) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
        Integer i = userService.updatePassWord(userName);//调用service层方法updatePassWord()，通过名称来进行操作数据
        if (i > 0) {
            return new Result(0, "重置成功");//把查到的结果数据，返回给前端ajax的请求
        }
        return new Result(1, "重置失败");//把查到的结果数据，返回给前端ajax的请求
    }

    @RequestMapping("getUserByUid") // 客户端请求地址
    public Object getSignByUid(Integer uid) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
        User i = userService.getById(uid);//调用mybatis plus的内 置service层方法getById()，查询某个数据
        if (i != null) {
            return new Result(0, "查询成功", i);//把查到的结果数据，返回给前端ajax的请求
        }
        return new Result(1, "查询失败");//把查到的结果数据，返回给前端ajax的请求
    }

    @RequestMapping("lockUser") // 客户端请求地址
    public Object lockUser(Integer isLockout, Integer uid,String token) throws IOException {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
           Token tokenId = JwtToken.unsign(token, Token.class);
            if (tokenId != null && tokenId.getUid().equals(uid)) {
                return new Result(1, "当前用户正在使用，不能锁定");
            } else {
                Integer i=userService.lockUser(uid,isLockout);//调用service层的方法，返回根据uid（用户id）,isLockout（是否锁定）

                if (userService.lockUser(uid,isLockout) > 0) {
                    return new Result(0, "成功");//把查到的结果数据，返回给前端ajax的请求

                } else {
                    return new Result(1, "凉了");//把查到的结果数据，返回给前端ajax的请求
                }
            }

    }
    /**
     * 全查
     * @return
     */
    @RequestMapping("getRegisterLayUI") // 客户端请求地址
    public Object getRegisterLayUI() {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        List<User> list = userService.list();//调用mybatis plus的内 置service层方法list()，查询全部数据

        return new Result(0, "", list);//把查到的全部数据，返回给前端ajax的请求
    }

    /**
     * 修改权重
     */

    @RequestMapping("updateRegister") // 客户端请求地址
    public Object updateWeight(User user) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        boolean updateRegister = userService.updateById(user);//调用mybatis plus的内 置service层方法updateById()，修改数据

        if (updateRegister) {

            return new Result(0, "修改成功");//把查到的结果数据，返回给前端ajax的请求

        }
        return new Result(1, "修改失败");//把查到的结果数据，返回给前端ajax的请求
    }
    
    @RequestMapping("getRname") // 客户端请求地址
    public Object getRname(Integer rid){//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙

        return userService.getRname(rid);
    }
    @RequestMapping("setPwd") // 客户端请求地址
    public Object updatePassword(String token, String newPassword, String oldPassword, String confirmPassword) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
        String resultString = MD5Utils.stringToMD5(newPassword);
        String oldPassword2 = MD5Utils.stringToMD5(oldPassword);
        String confirmPassword2 = MD5Utils.stringToMD5(confirmPassword);
        Token user;
        int u = 0;
        try {
            user = JwtToken.unsign(token, Token.class);
            if (user != null && user.getPassword().equals(oldPassword2)) {
                if (!resultString.equals(oldPassword2)) {
                    if (resultString.equals(confirmPassword2)) {
                        u = userService.setPwd(user.getUid(), resultString);
                    } else {

                        return new Result(1,"确认密码与新密码输入不一致");//把查到的结果数据，返回给前端ajax的请求
                    }
                } else {

                    return new Result(1,"新密码不能和原密码重复");//把查到的结果数据，返回给前端ajax的请求
                }
            } else {

                return new Result(1,"原密码输入错误");//把查到的结果数据，返回给前端ajax的请求
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (u > 0) {
            return new Result(0,"修改成功");//把查到的结果数据，返回给前端ajax的请求
        }
        return new Result();
    }
    /**
     * 拍照上传头像
     * @return
     */
    @RequestMapping("/uploadHeadImg") // 客户端请求地址
    public Object uploadHeadImg(String headImg,Integer uid) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
        String[] split = headImg.split(",");
        String s = split[1];
        String s1 = PhotoUtil.GenerateImage(s,uid,userService);
        if (!s1.equals("")) {
            map.put("success", true);
            map.put("message", s1);
        }
        else{
            map.put("success",true);
        }
        return map;
    }

    @RequestMapping("getUserById") // 客户端请求地址
    public Object getSignById(Integer uid,String password1) {//返 回值和方法名，object表示可以返回任何对象，因为object是任何对象的父对象，要父给子没问匙
        String password2=MD5Utils.stringToMD5(password1);
        User i = userService.getById(uid);//调用mybatis plus的内 置service层方法getById()，查询某个数据

        if (password2.equals(i.getPassword())) {
            return new Result(0, "查询成功");//把查到的结果数据，返回给前端ajax的请求
        }else{
            return new Result(1, "查询失败");//把查到的结果数据，返回给前端ajax的请求
        }

    }
}